# -*- coding: utf-8 -*-
"""
Created on Sun Nov  4 17:04:18 2018

@author: Sz-wyz
"""
'''
将本章中的代码整合为一个类
'''


import codecs
from math import sqrt

users = {"Angelica": {"Blues Traveler": 3.5, "Broken Bells": 2.0,
                      "Norah Jones": 4.5, "Phoenix": 5.0,
                      "Slightly Stoopid": 1.5,
                      "The Strokes": 2.5, "Vampire Weekend": 2.0},
         
         "Bill":{"Blues Traveler": 2.0, "Broken Bells": 3.5,
                 "Deadmau5": 4.0, "Phoenix": 2.0,
                 "Slightly Stoopid": 3.5, "Vampire Weekend": 3.0},
         
         "Chan": {"Blues Traveler": 5.0, "Broken Bells": 1.0,
                  "Deadmau5": 1.0, "Norah Jones": 3.0, "Phoenix": 5,
                  "Slightly Stoopid": 1.0},
         
         "Dan": {"Blues Traveler": 3.0, "Broken Bells": 4.0,
                 "Deadmau5": 4.5, "Phoenix": 3.0,
                 "Slightly Stoopid": 4.5, "The Strokes": 4.0,
                 "Vampire Weekend": 2.0},
         
         "Hailey": {"Broken Bells": 4.0, "Deadmau5": 1.0,
                    "Norah Jones": 4.0, "The Strokes": 4.0,
                    "Vampire Weekend": 1.0},
         
         "Jordyn":  {"Broken Bells": 4.5, "Deadmau5": 4.0,
                     "Norah Jones": 5.0, "Phoenix": 5.0,
                     "Slightly Stoopid": 4.5, "The Strokes": 4.0,
                     "Vampire Weekend": 4.0},
         
         "Sam": {"Blues Traveler": 5.0, "Broken Bells": 2.0,
                 "Norah Jones": 3.0, "Phoenix": 5.0,
                 "Slightly Stoopid": 4.0, "The Strokes": 5.0},
         
         "Veronica": {"Blues Traveler": 3.0, "Norah Jones": 5.0,
                      "Phoenix": 4.0, "Slightly Stoopid": 2.5,
                      "The Strokes": 3.0}
        }
         
class recommender:
    '''
    初始化recommender类
    k 最近邻居的k值
    metric 使用的距离公式
    n 推荐数
    '''
    def __init__(self,data,k=1,metric = 'pearson',n=5):
        self.k = k
        self.n = n
        self.username2id = {}
        self.userid2name = {}
        self.productid2name = {}
        self.metric = metric
        if self.metric == 'pearson':
            self.fn = self.pearson
        if type(data).__name__ =='dict':
            self.data = data
            
    def convertProductID2name(self,id):
        '''
        如果用户id存在于productid2name 返回书名
        '''
        if id in self.productid2name:
            return self.productid2name[id]
        else:
            return id
        
    def userRatings(self,id,n):
        '''
        返回前n个ratings
        此函数不适用于users -- 没对users进行合适的初始化
        通过loadBookDB导入的书本数据集可使用
        '''
        print("Rating for " + self.userid2name[id])#打印用户信息
        ratings = self.data[id]#评分信息
        print(len(ratings))
        ratings = list(ratings.items())
        ratings = [(self.convertProductID2name(k),v) for (k,v) in ratings]#返回书名
        ratings.sort(key = lambda artistTuple: artistTuple[1],reverse = True)#按照评分排序
        ratings = ratings[:n]#前n个书评信息
        for rating in ratings:
            print("%s\t%i"%(rating[0],rating[1]))
   
    def loadBookDB(self,path = ''):
        '''
        加载BX数据集 path是BX文件所在的位置
        '''
        self.data = {}
        i = 0 #总共的行数
        f = codecs.open(path + "BX-Book-Ratings.csv","r","utf-8")
        for line in f:#将读者对不同的书的评价整合
            i += 1
            fields = line.split(';')#csv文件以分号分隔
            user = fields[0].strip('"')
            book = fields[1].strip('"')
            rating = int(fields[2].strip().strip('"'))
            if user in self.data:
                currentRatings = self.data[user]
            else:
                currentRatings = {}
            currentRatings[book] = rating
            self.data[user] = currentRatings
#        print(self.data)#{读者：{书：评分，书:评分}，读者：{书：评分，书:评分}}
        f.close()
    
        f = codecs.open(path + "BX-Books.csv",'r','utf-8')#关于书的信息，isbn 书名 作者等
        for line in f:
            i += 1
            fields = line.split(':')
            isbn = fields[0].strip('"')
            title = fields[1].strip('"')
            author = fields[2].strip().strip('"')
            title = title + 'by' + author
            self.productid2name[isbn] = title 
        f.close()
        
        f = codecs.open(path + "BX-Users.csv",'r','utf-8')#关于读者的信息
        for line in f:
            i += 1
            fields = line.split(';')
            userid = fields[0].strip('"')
            location = fields[1].strip('"')
            if len(fields) > 3:
                age = fields[2].strip().strip('"')
            else:
                age = 'NULL'
            if age != 'NULL':
                value = location + ' (age: ' + age + ')'
            else:
                value = location
            self.userid2name[userid] = value
            self.username2id[location] = userid
        f.close()
        
    def pearson(self,rating1,rating2):
        sum_xy = 0
        sum_x = 0
        sum_y = 0
        sum_x2 = 0
        sum_y2 = 0
        n = 0
        for key in rating1:
            if key in rating2:
                n += 1
                x = rating1[key]
                y = rating2[key]
                sum_xy += x*y
                sum_x += x
                sum_y += y
                sum_x2 += pow(x,2)
                sum_y2 += pow(y,2)
        if n==0 :
            return 0
        denominator = (sqrt(sum_x2 - pow(sum_x,2) / n) * sqrt(sum_y2 - pow(sum_y,2)/n))
        if denominator == 0:
            return 0
        else:
            return (sum_xy - (sum_x*sum_y)/n)/denominator
        
    def computeNearestNeighbor(self,username):
        '''
        根据用户的距离创建用户的排序列表
        '''
        distances = []
        for instance in self.data:
            if instance != username:
                distance = self.fn(self.data[username],self.data[instance])#fn为距离公式
                distances.append((instance,distance))
        distances.sort(key = lambda artistTuple: artistTuple[1],reverse = True)
        return distances
    
    def recommend(self,user):
        recommendations = {}#推荐列表
        nearest = self.computeNearestNeighbor(user)
        userRatings = self.data[user]
        totalDistance = 0.0
        for i in range(self.k):
            totalDistance += nearest[i][1]
        for i in range(self.k):
            weight = nearest[i][1] / totalDistance
            name = nearest[i][0]
            neighborRatings = self.data[name]
            for artist in neighborRatings:
                if not artist in userRatings:
                    if artist not in recommendations:
                        recommendations[artist] = (neighborRatings[artist]*weight)
                    else:
                        recommendations[artist] = (recommendations[artist]\
                                        + neighborRatings[artist] *weight)
        recommendations = list(recommendations.items())
        recommendations = [(self.convertProductID2name(k),v) for \
                           (k,v) in recommendations]
        recommendations.sort(key = lambda artistTuple: artistTuple[1],reverse = True)
        return recommendations[:self.n]#返回前n个推荐
    
                
    
    